﻿#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;
#if 0
class Date
{
public:
	//默认构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//这个函数可以不写，默认的的够用
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 7, 16);
	//将d1赋值给d2
	Date d2(d1);

	return 0;
}
#endif

#if 0
#include<iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
	//默认构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//拷贝构造函数
	Stack(const Stack& st)
	{
		//需要对_a指向资源创建同样大的资源再拷⻉值
		 _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		 _top = st._top;
		_capacity = st._capacity;
		}
		//入栈
		void Push(STDataType x)
		{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType * tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			
				_a = tmp;
			_capacity = newcapacity;
			}
	
			_a[_top++] = x;
		}
	//析构函数
	 ~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType * _a;
	size_t _capacity;
	size_t _top;
};

//两个Stack实现队列
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	//Stack不显示实现拷⻉构造，用自动生成的拷⻉构造完成浅拷⻉
	//会导致st1和st2里面的_a指针指向同一块资源，析构时会析构两次，程序崩溃
	Stack st2(st1);
	MyQueue mq1;
	//MyQueue自动生成的拷⻉构造，会自动调用Stack拷⻉构造完成pushst/popst
	//的拷⻉，只要Stack拷⻉构造自己实现了深拷⻉，他就没问题
	MyQueue mq2 = mq1;

	return 0;
}
#endif

//#include <iostream>
//using namespace std;
//
//Stack function()
//{
//	Stack st;
//	return st;
//}
//
//int main()
//{
//	Stack ret = function();
//
//	return 0;
//}

//int main()
//{
//	//int rand = 10;
//	srand((unsigned int)time(NULL));
//	int i = rand() % 100 + 1;
//	printf("%d\n", i);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class A
//{
//public:
//	void Func()
//	{
//		cout << "A::Func()" << endl;
//	}
//};
//
//成员函数指针类型
//typedef void(A::*PF)();
//
//int main()
//{
//	//void(A:: * pf)() = nullptr;
//	PF pf = nullptr;
//
//	//C++规定成员函数要加&才可以取到函数指针
//	pf = &A::Func;
//	A a;
//	(a.*pf)();
//
//	return 0;
//}

#if 0
#include <iostream>
using namespace std;

class Date
{
public:
	//默认构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//运算符重载函数
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	//这个函数可以不写，默认的就够用
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 7, 16);
	Date d2(d1);

	if (d1.operator==(d2))
	//if (d1 == d1)
		//写d1 == d2也会自动转成d1.operator==(d2)
	{
		printf("Copyed succesfully!");
	}
}
#endif


#include <iostream>
using namespace std;

class Date
{
public:
	//默认构造函数
	Date(int year, int month, int day);

	//拷贝构造函数
	Date(const Date& d);

	//赋值运算符重载函数 - 需要有返回值且当前类类型引用返回
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}

	//打印日期
	void Print();
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 7, 16);
	//拷贝构造
	Date d2(d1);
	Date d3 = d2;

	//赋值重载拷贝
	d2 = d3;

	return 0;
}